package com.ycsj.common.utils;


import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.JsonPrimitive;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.reflect.TypeToken;

import java.io.Reader;
import java.lang.reflect.Type;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * 利用Gson解析json字符串的工具类,包含集合对象转json,json换集合对象,对象转json,
 * json转对象
 * Created by Administrator on 2016/5/25.
 */
public class GsonUtil {

    //申明Gson对象
    private static Gson gson = null;

    //在静态方法中初始化
    static {
        if (gson == null) {
            gson = new Gson();
        }
    }

    /**
     * 将对象转化为json格式
     *
     * @param ts
     * @return
     */
    public static String objectToJson(Object ts) {
        String jsonResult = null;
        if (gson != null) {
            jsonResult = gson.toJson(ts);
        }
        return jsonResult;
    }

    /**
     * 将对象转换成json格式(并自定义日期格式)
     *
     * @param ts
     * @param dateformat
     * @return
     */
    public static String objectToJson(Object ts, final String dateformat) {
        String jsonResult = null;
        gson = new GsonBuilder().registerTypeHierarchyAdapter(Date.class, new JsonSerializer<Date>() {
            public JsonElement serialize(Date src, Type typeOfSrc, JsonSerializationContext context) {
                SimpleDateFormat format = new SimpleDateFormat(dateformat);
                return new JsonPrimitive(format.format(src));
            }
        }).setDateFormat(dateformat).create();
        if (gson != null) {
            jsonResult = gson.toJson(ts);
        }
        return jsonResult;
    }

    /**
     * 将json格式字符串转化为list对象,对应的jsong字符串格式是[{....}],格式：对应最外层是[]
     * 调用时候传入第二个参数的格式为 Bean[].class
     *
     * @return
     */
    public static <T> List<T> jsonToList(String jsonStr, Class<T[]> cls) {
        T[] arr = null;
        if (gson != null) {
            arr = gson.fromJson(jsonStr, cls);
        }
        return Arrays.asList(arr);
    }

    /**
     * 将json字符串转化为Bean对象,对应json字符串格式为:最外层{}结尾
     *
     * @param jsonStr
     * @param cls
     * @return
     */
    public static <T> T jsonToBean(String jsonStr, Class<T> cls) {
        T obj = null;
        if (gson != null) {
            obj = gson.fromJson(jsonStr, cls);
        }
        return obj;
    }

    /**
     * 将json转换成bean对象(并自定义日期格式)
     *
     * @param jsonReader
     * @param cl
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T jsonToBean(Reader jsonReader, Class<T> cl, final String pattern) {
        Object obj = null;
        gson = new GsonBuilder().registerTypeAdapter(Date.class, new JsonDeserializer<Date>() {
            public Date deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
                    throws JsonParseException {
                SimpleDateFormat format = new SimpleDateFormat(pattern);
                String dateStr = json.getAsString();
                try {
                    return format.parse(dateStr);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
        }).setDateFormat(pattern).create();
        if (gson != null) {
            obj = gson.fromJson(jsonReader, cl);
        }
        return (T) obj;
    }


    /**
     * 将集合转化为json字符串
     *
     * @param list
     * @param <T>
     * @return
     */
    public static <T> String listToJson(List<T> list) {
        String result = null;
        if (gson != null) {
            result = gson.toJson(list);
        }
        return result;
    }


    /**
     * 将一个Json字符串转化为Map集合
     *
     * @param jsonString
     * @return
     */
//    public static Map<String, Object> getMap4Json(String jsonString) {
//        Map<String, Object> valueMap = new HashMap<String, Object>();
//        JSONTokener jsonParser = new JSONTokener(jsonString);
//        // 此时还未读取任何json文本，直接读取就是一个JSONObject对象。
//        try {
//            JSONObject person = (JSONObject) jsonParser.nextValue();
//            @SuppressWarnings("rawtypes")
//            Iterator iterator = person.keys();
//            while (iterator.hasNext()) {
//                String key = iterator.next().toString();
//                valueMap.put(key, person.getString(key));
//            }
//        } catch (JSONException e) {
//            // TODO Auto-generated catch block
//            e.printStackTrace();
//        }
//        return valueMap;
//    }


    /**
     * 转成map的
     *
     * @param gsonString
     * @return
     */
    public static <T> Map<String, T> GsonToMap(String gsonString) {
        Map<String, T> map = null;
        if (gson != null) {
            map = gson.fromJson(gsonString, new TypeToken<Map<String, T>>() {
            }.getType());
        }
        return map;
    }


    /**
     * 转成list中有map的
     *
     * @param gsonString
     * @return
     */
    public static <T> List<Map<String, T>> GsonToListMaps(String gsonString) {
        List<Map<String, T>> list = null;
        if (gson != null) {
            list = gson.fromJson(gsonString,
                    new TypeToken<List<Map<String, T>>>() {
                    }.getType());
        }
        return list;
    }

    /**
     * 转成map的
     *
     * @param gsonString
     * @param mapClass
     * @return
     */
    public static <T> Map<String, T> GsonToMaps(String gsonString, Class<Map> mapClass) {
        Map<String, T> map = null;
        if (gson != null) {
            map = gson.fromJson(gsonString, new TypeToken<Map<String, T>>() {
            }.getType());
        }
        return map;
    }

}
